{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 实验十 基于ResNet的猫狗识别实验报告\n",
    "## 学号：20221200556 姓名：杨鑫其\n",
    "\n",
    "## 实验目的\n",
    "1. 掌握ResNet原理及PyTorch在图像分类中的应用。\n",
    "2. 使用ResNet-18实现猫狗二分类，测试集准确率≥90%。\n",
    "3. 可视化损失、准确率曲线及预测结果。\n",
    "\n",
    "## 实验环境\n",
    "- **操作系统**: Windows 10\n",
    "- **开发工具**: PyCharm, Jupyter Notebook\n",
    "- **编程语言**: Python 3.9\n",
    "- **库**: torch, torchvision, numpy, matplotlib, pillow\n",
    "\n",
    "**安装命令**:\n",
    "```bash\n",
    "pip install torch torchvision numpy matplotlib pillow\n",
    "```\n",
    "\n",
    "## 实验内容\n",
    "使用Kaggle猫狗数据集（https://www.kaggle.com/c/dogs-vs-cats/data），结构如下：\n",
    "```\n",
    "E:\\Code\\实训\\\n",
    "├── training_set/\n",
    "│   ├── cats/\n",
    "│   └── dogs/\n",
    "├── test_set/\n",
    "│   ├── cats/\n",
    "│   └── dogs/\n",
    "```\n",
    "目标：训练ResNet-18模型，测试准确率≥90%，可视化结果。\n",
    "\n",
    "**注意**：数据集路径已更新为 `E:\\\\Code\\\\实训` 以匹配本地环境。如需调整，请修改代码中的 `Config.DATA_DIR`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-24T13:02:39.797490Z",
     "start_time": "2025-06-24T13:02:39.784857Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验步骤\n",
    "### 1. 数据准备\n",
    "下载Kaggle数据集，整理为上述结构，训练集约8000张，测试集约2000张。\n",
    "\n",
    "### 2. 数据预处理\n",
    "应用数据增强（训练集）及标准化，创建数据加载器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-24T11:13:28.351986Z",
     "start_time": "2025-06-24T11:12:53.360298Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集样本数: 8005\n",
      "测试集样本数: 2023\n",
      "类别: ['cats', 'dogs']\n",
      "图像形状: torch.Size([32, 3, 224, 224]), 标签形状: torch.Size([32])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.datasets import ImageFolder\n",
    "from torch.utils.data import DataLoader\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import shutil\n",
    "\n",
    "# 设置随机种子\n",
    "torch.manual_seed(1)\n",
    "\n",
    "# 配置类\n",
    "class Config:\n",
    "    IMAGE_SIZE = (224, 224)  # ResNet 输入尺寸\n",
    "    BATCH_SIZE = 32\n",
    "    NUM_WORKERS = 4\n",
    "\n",
    "# 图像预处理\n",
    "transform_train = transforms.Compose([\n",
    "    transforms.Resize(Config.IMAGE_SIZE),\n",
    "    transforms.RandomRotation(15),\n",
    "    transforms.RandomHorizontalFlip(p=0.5),\n",
    "    transforms.RandomAffine(\n",
    "        degrees=0,\n",
    "        translate=(0.1, 0.1),\n",
    "        shear=10,\n",
    "        scale=(0.8, 1.2),\n",
    "    ),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "])\n",
    "\n",
    "transform_valid = transforms.Compose([\n",
    "    transforms.Resize(Config.IMAGE_SIZE),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "])\n",
    "\n",
    "def organize_kaggle_data(source_dir='./dogs-vs-cats/training_set', dest_dir='./dogs-vs-cats'):\n",
    "    \"\"\"将 Kaggle 原始数据整理为指定结构\"\"\"\n",
    "    if not os.path.exists(source_dir):\n",
    "        raise FileNotFoundError(f\"Source directory {source_dir} not found. Please download and extract train.zip from https://www.kaggle.com/c/dogs-vs-cats/data.\")\n",
    "\n",
    "    # 创建目标目录\n",
    "    train_cats_dir = os.path.join(dest_dir, 'training_set/training_set', 'cats')\n",
    "    train_dogs_dir = os.path.join(dest_dir, 'training_set/training_set', 'dogs')\n",
    "    test_cats_dir = os.path.join(dest_dir, 'test_set/test_set', 'cats')\n",
    "    test_dogs_dir = os.path.join(dest_dir, 'test_set/test_set', 'dogs')\n",
    "    os.makedirs(train_cats_dir, exist_ok=True)\n",
    "    os.makedirs(train_dogs_dir, exist_ok=True)\n",
    "    os.makedirs(test_cats_dir, exist_ok=True)\n",
    "    os.makedirs(test_dogs_dir, exist_ok=True)\n",
    "\n",
    "    # 按文件名序号分割训练和测试（前80%训练，后20%测试）\n",
    "    cat_files = sorted([f for f in os.listdir(source_dir) if f.startswith('cat.')])\n",
    "    dog_files = sorted([f for f in os.listdir(source_dir) if f.startswith('dog.')])\n",
    "    split_idx = int(0.8 * len(cat_files))\n",
    "\n",
    "    for i, fname in enumerate(cat_files):\n",
    "        src = os.path.join(source_dir, fname)\n",
    "        dst = os.path.join(train_cats_dir if i < split_idx else test_cats_dir, fname)\n",
    "        if not os.path.exists(dst):\n",
    "            shutil.copy(src, dst)\n",
    "\n",
    "    for i, fname in enumerate(dog_files):\n",
    "        src = os.path.join(source_dir, fname)\n",
    "        dst = os.path.join(train_dogs_dir if i < split_idx else test_dogs_dir, fname)\n",
    "        if not os.path.exists(dst):\n",
    "            shutil.copy(src, dst)\n",
    "\n",
    "def load_dogs_vs_cats_data(train_dir='./dogs-vs-cats/training_set/training_set', test_dir='./dogs-vs-cats/test_set/test_set'):\n",
    "    \"\"\"加载猫狗数据集并创建数据加载器\"\"\"\n",
    "    # 检查目录\n",
    "    if not os.path.exists(train_dir) or not os.path.exists(test_dir):\n",
    "        print(f\"Train or test directory not found. Organizing data from Kaggle source...\")\n",
    "        organize_kaggle_data()\n",
    "\n",
    "    # 加载数据集\n",
    "    train_dataset = ImageFolder(train_dir, transform=transform_train)\n",
    "    test_dataset = ImageFolder(test_dir, transform=transform_valid)\n",
    "\n",
    "    # 创建数据加载器\n",
    "    train_loader = DataLoader(train_dataset, batch_size=Config.BATCH_SIZE, shuffle=True,\n",
    "                              num_workers=Config.NUM_WORKERS, pin_memory=True)\n",
    "    test_loader = DataLoader(test_dataset, batch_size=Config.BATCH_SIZE, shuffle=False,\n",
    "                             num_workers=Config.NUM_WORKERS, pin_memory=True)\n",
    "\n",
    "    return train_loader, test_loader, train_dataset, test_dataset\n",
    "\n",
    "# 加载数据\n",
    "try:\n",
    "    train_loader, test_loader, train_dataset, test_dataset = load_dogs_vs_cats_data()\n",
    "    print(f\"训练集样本数: {len(train_dataset)}\")\n",
    "    print(f\"测试集样本数: {len(test_dataset)}\")\n",
    "    print(f\"类别: {train_dataset.classes}\")\n",
    "    data_iter = iter(train_loader)\n",
    "    images, labels = next(data_iter)\n",
    "    print(f\"图像形状: {images.shape}, 标签形状: {labels.shape}\")\n",
    "except Exception as e:\n",
    "    print(f\"Error in data loading: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 定义模型\n",
    "使用预训练ResNet-18，修改全连接层为二分类。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-24T11:13:28.820417Z",
     "start_time": "2025-06-24T11:13:28.357112Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型初始化完成\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "from torchvision.models import resnet18, ResNet18_Weights\n",
    "\n",
    "# 定义模型\n",
    "class ResNet18Classifier(nn.Module):\n",
    "    def __init__(self, num_classes=2):\n",
    "        super(ResNet18Classifier, self).__init__()\n",
    "        self.resnet = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)\n",
    "        for param in self.resnet.parameters():\n",
    "            param.requires_grad = False\n",
    "        self.resnet.fc = nn.Linear(self.resnet.fc.in_features, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.resnet(x)\n",
    "\n",
    "# 初始化模型\n",
    "try:\n",
    "    model = ResNet18Classifier().to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))\n",
    "    print('模型初始化完成')\n",
    "except Exception as e:\n",
    "    print(f'模型初始化错误: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 训练模型\n",
    "训练20个epoch，记录损失和准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-24T12:40:05.507299Z",
     "start_time": "2025-06-24T11:13:28.824418Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20, Train Loss: 0.2012, Train Acc: 0.9220, Test Loss: 0.1182, Test Acc: 0.9570\n",
      "Epoch 2/20, Train Loss: 0.1216, Train Acc: 0.9538, Test Loss: 0.0828, Test Acc: 0.9733\n",
      "Epoch 3/20, Train Loss: 0.1215, Train Acc: 0.9522, Test Loss: 0.0707, Test Acc: 0.9728\n",
      "Epoch 4/20, Train Loss: 0.1076, Train Acc: 0.9564, Test Loss: 0.0900, Test Acc: 0.9644\n",
      "Epoch 5/20, Train Loss: 0.1147, Train Acc: 0.9519, Test Loss: 0.0762, Test Acc: 0.9748\n",
      "Epoch 6/20, Train Loss: 0.1046, Train Acc: 0.9582, Test Loss: 0.0725, Test Acc: 0.9728\n",
      "Epoch 7/20, Train Loss: 0.0997, Train Acc: 0.9608, Test Loss: 0.0706, Test Acc: 0.9753\n",
      "Epoch 8/20, Train Loss: 0.1039, Train Acc: 0.9582, Test Loss: 0.1188, Test Acc: 0.9530\n",
      "Epoch 9/20, Train Loss: 0.1103, Train Acc: 0.9553, Test Loss: 0.0717, Test Acc: 0.9743\n",
      "Epoch 10/20, Train Loss: 0.1175, Train Acc: 0.9517, Test Loss: 0.0825, Test Acc: 0.9698\n",
      "Epoch 11/20, Train Loss: 0.1025, Train Acc: 0.9598, Test Loss: 0.0630, Test Acc: 0.9763\n",
      "Epoch 12/20, Train Loss: 0.1031, Train Acc: 0.9599, Test Loss: 0.0627, Test Acc: 0.9763\n",
      "Epoch 13/20, Train Loss: 0.1061, Train Acc: 0.9562, Test Loss: 0.0845, Test Acc: 0.9674\n",
      "Epoch 14/20, Train Loss: 0.0917, Train Acc: 0.9640, Test Loss: 0.0715, Test Acc: 0.9763\n",
      "Epoch 15/20, Train Loss: 0.1089, Train Acc: 0.9555, Test Loss: 0.0642, Test Acc: 0.9783\n",
      "Epoch 16/20, Train Loss: 0.0913, Train Acc: 0.9634, Test Loss: 0.0906, Test Acc: 0.9664\n",
      "Epoch 17/20, Train Loss: 0.1133, Train Acc: 0.9554, Test Loss: 0.0691, Test Acc: 0.9758\n",
      "Epoch 18/20, Train Loss: 0.0986, Train Acc: 0.9604, Test Loss: 0.0753, Test Acc: 0.9723\n",
      "Epoch 19/20, Train Loss: 0.0977, Train Acc: 0.9618, Test Loss: 0.0631, Test Acc: 0.9773\n",
      "Epoch 20/20, Train Loss: 0.0947, Train Acc: 0.9621, Test Loss: 0.0665, Test Acc: 0.9768\n",
      "Final test accuracy: 0.9768\n"
     ]
    }
   ],
   "source": [
    "def train_model(model, train_loader, test_loader, epochs=20, lr=0.001):\n",
    "    \"\"\"训练模型并记录损失和准确率\"\"\"\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    model = model.to(device)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer = optim.Adam(model.resnet.fc.parameters(), lr=lr)  # 仅优化全连接层\n",
    "\n",
    "    train_losses, test_losses = [], []\n",
    "    train_accuracies, test_accuracies = [], []\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        # 训练\n",
    "        model.train()\n",
    "        running_loss = 0.0\n",
    "        correct = 0\n",
    "        total = 0\n",
    "        for images, labels in train_loader:\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(images)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            running_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "\n",
    "        train_loss = running_loss / len(train_loader)\n",
    "        train_acc = correct / total\n",
    "        train_losses.append(train_loss)\n",
    "        train_accuracies.append(train_acc)\n",
    "\n",
    "        # 测试\n",
    "        model.eval()\n",
    "        test_loss = 0.0\n",
    "        correct = 0\n",
    "        total = 0\n",
    "        with torch.no_grad():\n",
    "            for images, labels in test_loader:\n",
    "                images, labels = images.to(device), labels.to(device)\n",
    "                outputs = model(images)\n",
    "                loss = criterion(outputs, labels)\n",
    "                test_loss += loss.item()\n",
    "                _, predicted = torch.max(outputs, 1)\n",
    "                total += labels.size(0)\n",
    "                correct += (predicted == labels).sum().item()\n",
    "\n",
    "        test_loss = test_loss / len(test_loader)\n",
    "        test_acc = correct / total\n",
    "\n",
    "        test_accuracies.append(test_acc)\n",
    "\n",
    "        print(f\"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.4f}\")\n",
    "\n",
    "    return train_losses, train_accuracies, test_losses, test_accuracies\n",
    "\n",
    "# 训练模型\n",
    "try:\n",
    "    train_losses, train_accuracies, test_losses, test_accuracies = train_model(model, train_loader, test_loader)\n",
    "    final_test_acc = test_accuracies[-1]\n",
    "    if final_test_acc < 0.90:\n",
    "        print(\"Warning: Test accuracy below 90%. Consider increasing epochs, unfreezing layers, or adjusting learning rate.\")\n",
    "    else:\n",
    "        print(f\"Final test accuracy: {final_test_acc:.4f}\")\n",
    "except Exception as e:\n",
    "    print(f\"Error in training: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 可视化结果\n",
    "绘制损失、准确率曲线及前10个测试样本的预测结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-24T12:41:41.371387Z",
     "start_time": "2025-06-24T12:41:24.985781Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x300 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def visualize_predictions(model, test_loader, class_names, num_images=10):\n",
    "    \"\"\"可视化预测结果、真实标签及对应图像\"\"\"\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    model.eval()\n",
    "    images, labels = next(iter(test_loader))\n",
    "    images, labels = images[:num_images].to(device), labels[:num_images].to(device)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "\n",
    "    plt.figure(figsize=(15, 3))\n",
    "    for i in range(num_images):\n",
    "        plt.subplot(2, 5, i + 1)\n",
    "        img = images[i].cpu().numpy().transpose(1, 2, 0)  # 转换为 HxWxC\n",
    "        img = img * np.array([0.229, 0.224, 0.225]) + np.array([0.485, 0.456, 0.406])  # 反标准化\n",
    "        img = np.clip(img, 0, 1)\n",
    "        plt.imshow(img)\n",
    "        plt.title(f'Pred: {class_names[predicted[i].item()]}\\nTrue: {class_names[labels[i].item()]}')\n",
    "        plt.axis('off')\n",
    "    plt.suptitle('Dogs vs. Cats Predictions')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# 可视化预测\n",
    "try:\n",
    "    class_names = train_dataset.classes  # ['cats', 'dogs']\n",
    "    visualize_predictions(model, test_loader, class_names)\n",
    "except NameError as e:\n",
    "    print(f\"Error: {e}. Please ensure model, test_loader, and train_dataset are defined.\")\n",
    "except Exception as e:\n",
    "    print(f\"Visualization error: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验结果与结论\n",
    "- **结果**：ResNet-18测试集准确率达97.68%，满足≥90%目标。损失曲线下降，准确率曲线上升，预测可视化显示大多数样本正确分类。\n",
    "- **结论**：ResNet-18通过迁移学习在猫狗分类任务上表现优异，数据增强和预训练权重有效提升性能。未来可尝试微调更多层或增加数据增强以进一步优化。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
